home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / FireMan.swf / scripts / frame_1134 / PlaceObject2_276_1146 / CLIPACTIONRECORD onClipEvent(enterFrame).as next >
Text File  |  2008-09-12  |  14KB  |  572 lines
  1. onClipEvent(enterFrame){
  2.    function hitPlatforms()
  3.    {
  4.       var u;
  5.       u = suelo = sueloI = sueloD = false;
  6.       i = -9;
  7.       while(i <= 0)
  8.       {
  9.          sueloI = sueloI || mapa.hitTest(_X + i,_Y,true);
  10.          i++;
  11.       }
  12.       i = 1;
  13.       while(i <= 9)
  14.       {
  15.          sueloD = sueloD || mapa.hitTest(_X + i,_Y,true);
  16.          i++;
  17.       }
  18.       if(sueloI && wallizq() && !sueloD && !techo)
  19.       {
  20.          return undefined;
  21.       }
  22.       if(sueloD && wallder() && !sueloI && !techo)
  23.       {
  24.          return undefined;
  25.       }
  26.       suelo = sueloI || sueloD;
  27.       if(suelo)
  28.       {
  29.          falling = false;
  30.          currenthigh = 0;
  31.          techo = false;
  32.          if(s)
  33.          {
  34.             landing.start();
  35.             s = false;
  36.          }
  37.          j = -15;
  38.          while(j <= 15)
  39.          {
  40.             i = -9;
  41.             while(i <= 9)
  42.             {
  43.                if(mapa.hitTest(_X + i,_Y + j,true) && !mapa.hitTest(_X + i,_Y + j - 1,true))
  44.                {
  45.                   u = true;
  46.                   break;
  47.                }
  48.                i++;
  49.             }
  50.             if(u)
  51.             {
  52.                break;
  53.             }
  54.             j++;
  55.          }
  56.          _Y = _Y + j;
  57.          j = vertical = 0;
  58.       }
  59.       return undefined;
  60.    }
  61.    function roof()
  62.    {
  63.       var u = techo = false;
  64.       i = -3;
  65.       while(i <= 3)
  66.       {
  67.          if(mapa.hitTest(_X + i,_Y - 30,true))
  68.          {
  69.             u = techo = true;
  70.             break;
  71.          }
  72.          i++;
  73.       }
  74.       return u;
  75.    }
  76.    function gridx(a)
  77.    {
  78.       return int(a / GRIDSIZE);
  79.    }
  80.    function gridy(b)
  81.    {
  82.       if(b >= 0)
  83.       {
  84.          return int(b / GRIDSIZE);
  85.       }
  86.       return Math.floor(b / GRIDSIZE);
  87.    }
  88.    function render()
  89.    {
  90.       if(!death)
  91.       {
  92.          scrollspeed = 0;
  93.          if(this.hitTest(_root.scrollmask))
  94.          {
  95.             doscroll = true;
  96.          }
  97.          if(_root.topeizq._x >= 0 && horizontal < 0 || _root.topeder._x <= 256 && horizontal > 0)
  98.          {
  99.             doscroll = false;
  100.          }
  101.          if(doscroll)
  102.          {
  103.             _X = lastX;
  104.             scrollspeed = setSpeed() + _root.windx;
  105.          }
  106.          lastX = _X;
  107.          lastY = _Y;
  108.          if(timerdamage == 0 && hitted && !invisible)
  109.          {
  110.             timerdamage = FLASHTIME;
  111.             timerinvisible = INVISIBLETIME;
  112.             keys = false;
  113.             _root.currentdamage += DAMAGE;
  114.             barra.gotoAndStop(_root.currentdamage + 1);
  115.             _parent.fhitted.start();
  116.             if(rising || jumping)
  117.             {
  118.                vertical = 0.5;
  119.                falling = true;
  120.             }
  121.          }
  122.          if(timerdamage > 0)
  123.          {
  124.             flashing = true;
  125.             timerdamage--;
  126.             if(_xscale < 0 && !wallder())
  127.             {
  128.                if(doscroll)
  129.                {
  130.                   scrollspeed = hforce / 2;
  131.                }
  132.                else
  133.                {
  134.                   horizontal = hforce / 2;
  135.                }
  136.             }
  137.             if(_xscale > 0 && !wallizq())
  138.             {
  139.                if(doscroll)
  140.                {
  141.                   scrollspeed = hforce / 2 * -1;
  142.                }
  143.                else
  144.                {
  145.                   horizontal = hforce / 2 * -1;
  146.                }
  147.             }
  148.          }
  149.          if(flashing && timerdamage == 0)
  150.          {
  151.             flashing = false;
  152.             keys = true;
  153.             timerinvisible = INVISIBLETIME;
  154.             invisible = true;
  155.          }
  156.          if(invisible)
  157.          {
  158.             timerinvisible--;
  159.             timerinvisible % 2 != 0 ? (_visible = false) : (_visible = true);
  160.          }
  161.          if(timerinvisible <= 0 && invisible)
  162.          {
  163.             invisible = false;
  164.             hitted = false;
  165.             _visible = true;
  166.          }
  167.          if(_root.currentdamage + 1 >= MAXDAMAGE)
  168.          {
  169.             death = true;
  170.             barra.gotoAndStop(MAXDAMAGE);
  171.             _root.fdeath.start();
  172.          }
  173.          DAMAGE = 0;
  174.          if(!shooting && abletoshoot)
  175.          {
  176.             if(Key.isDown(SHOOT) && keys)
  177.             {
  178.                justshoot = true;
  179.                abletoshoot = false;
  180.             }
  181.             else
  182.             {
  183.                justshoot = false;
  184.             }
  185.          }
  186.          if(justshoot && !shooting)
  187.          {
  188.             if(_xscale > 0)
  189.             {
  190.                shoot1._x = _X + 41;
  191.             }
  192.             else
  193.             {
  194.                shoot1._x = _X - 41;
  195.             }
  196.             if(!vertical)
  197.             {
  198.                shoot1._y = _Y - 14;
  199.             }
  200.             else
  201.             {
  202.                shoot1._y = _Y - 20;
  203.             }
  204.             shoot1._visible = true;
  205.             if(_xscale > 0)
  206.             {
  207.                shoot1.dx = Math.abs(shoot1.dx);
  208.                shoot1._xscale = Math.abs(shoot1._xscale);
  209.             }
  210.             if(_xscale < 0)
  211.             {
  212.                shoot1.dx = Math.abs(shoot1.dx) * -1;
  213.                shoot1._xscale = Math.abs(shoot1._xscale) * -1;
  214.             }
  215.             blast.start();
  216.             shooting = true;
  217.             justshoot = false;
  218.          }
  219.          if(!shooting && !abletoshoot)
  220.          {
  221.             if(!Key.isDown(SHOOT))
  222.             {
  223.                abletoshoot = true;
  224.             }
  225.          }
  226.          x = setSpeed();
  227.          if(!flashing)
  228.          {
  229.             horizontal = x;
  230.          }
  231.          if(vertical == 0 && Key.isDown(ARRIBA) && upreleased && keys)
  232.          {
  233.             vertical = vforce * -1;
  234.             horizontal += platform.dx;
  235.             platformscroll = 0;
  236.             rising = true;
  237.             upreleased = false;
  238.             salto.start();
  239.          }
  240.          if(!falling && !uprelease)
  241.          {
  242.             if(!Key.isDown(ARRIBA))
  243.             {
  244.                upreleased = true;
  245.             }
  246.          }
  247.          if(rising)
  248.          {
  249.             if(roof())
  250.             {
  251.                falling = true;
  252.                startfall = true;
  253.                rising = false;
  254.             }
  255.             if(currenthigh < MAXJUMP && Key.isDown(ARRIBA) && !upreleased && !flashing)
  256.             {
  257.                if(roof())
  258.                {
  259.                   startfall = true;
  260.                   falling = true;
  261.                   rising = false;
  262.                }
  263.                if(currenthigh < vforcei)
  264.                {
  265.                   vertical = - Math.abs(vforcei);
  266.                }
  267.                else
  268.                {
  269.                   vertical = - Math.abs(vforce);
  270.                }
  271.                currenthigh += Math.abs(vertical);
  272.             }
  273.             else
  274.             {
  275.                vertical *= gravity;
  276.                currenthigh += Math.abs(vertical);
  277.                if(Math.abs(vertical) < 1)
  278.                {
  279.                   startfall = true;
  280.                   falling = true;
  281.                   rising = false;
  282.                }
  283.             }
  284.          }
  285.          if(Key.isDown(SLIDEKEY) && !rising && !falling && keys && slidereleased)
  286.          {
  287.             if(_xscale < 0 && !wallizq())
  288.             {
  289.                slideLeft = true;
  290.                slideRight = false;
  291.             }
  292.             if(_xscale > 0 && !wallder())
  293.             {
  294.                slideLeft = false;
  295.                slideRight = true;
  296.             }
  297.             slide = slideLeft || slideRight;
  298.             slidereleased = false;
  299.          }
  300.          if(slide && slidetimer == 0)
  301.          {
  302.             slidetimer = SLIDETIME;
  303.          }
  304.          if(slide && slidetimer > 0)
  305.          {
  306.             slidetimer--;
  307.             if(slidetimer == 0 || Key.isDown(IZQ) && slideRight || Key.isDown(DER) && slideLeft || falling || wallizq() && slideLeft || wallder() && slideRight)
  308.             {
  309.                slide = slideLeft = slideRight = slidetimer = 0;
  310.             }
  311.          }
  312.          if(!Key.isDown(SLIDEKEY) && !slidereleased)
  313.          {
  314.             slidereleased = true;
  315.          }
  316.          if(falling)
  317.          {
  318.             s = true;
  319.             if(startfall)
  320.             {
  321.                vertical = Math.abs(vforcei / 2) * accel;
  322.                startfall = false;
  323.             }
  324.             else
  325.             {
  326.                vertical = Math.abs(vertical) * accel;
  327.             }
  328.             if(vertical > MAXVERTICAL)
  329.             {
  330.                vertical = MAXVERTICAL;
  331.             }
  332.             platformscroll = 0;
  333.             hitPlatforms();
  334.             if(_Y >= 245)
  335.             {
  336.                death = true;
  337.                _root.fdeath.start();
  338.             }
  339.          }
  340.          if(tornado)
  341.          {
  342.             floating = true;
  343.             playtornado = true;
  344.             vertical2 += vforce;
  345.             if(vertical2 > MAXVERTICAL)
  346.             {
  347.                vertical2 = MAXVERTICAL / 6;
  348.             }
  349.          }
  350.          else
  351.          {
  352.             playtornado = false;
  353.          }
  354.          if(floating && !rising)
  355.          {
  356.             if(tornado)
  357.             {
  358.                vertical = - vertical2;
  359.             }
  360.             else
  361.             {
  362.                vertical = -4;
  363.                floating = false;
  364.                rising = true;
  365.                vertical2 = 0;
  366.             }
  367.          }
  368.          if(playtornado && !soundtrigged)
  369.          {
  370.             _root.wind04.setVolume(100);
  371.             _root.wind04.start();
  372.             u = 100;
  373.             soundtrigged = true;
  374.          }
  375.          if(soundtrigged && !playtornado && u > 0)
  376.          {
  377.             u -= 5;
  378.             _root.wind04.setVolume(u);
  379.             if(u == 0)
  380.             {
  381.                _root.wind04.stop();
  382.                playtornado = true;
  383.                soundtrigged = false;
  384.             }
  385.          }
  386.          tornado = false;
  387.          if(_root.windx)
  388.          {
  389.             horizontal += _root.windx;
  390.          }
  391.          _Y = _Y + vertical + platform.dy;
  392.          if(horizontal < 0 && !wallizq() || horizontal > 0 && !wallder())
  393.          {
  394.             _X = _X + horizontal;
  395.          }
  396.          drawframe();
  397.          x1 = LastX - platform._x;
  398.          x2 = _X - platform._x;
  399.          if(!falling && !rising)
  400.          {
  401.             hitPlatforms();
  402.             if(!suelo)
  403.             {
  404.                vertical = 2;
  405.                falling = true;
  406.             }
  407.          }
  408.       }
  409.       else
  410.       {
  411.          drawframe();
  412.          vertical = horizontal = doscroll = scrollspeed = 0;
  413.          if(!f)
  414.          {
  415.             _root.fade.begin = true;
  416.             f = true;
  417.          }
  418.       }
  419.    }
  420.    function wallizq()
  421.    {
  422.       var u = false;
  423.       var t = !slide ? 12 : 20;
  424.       i = -24;
  425.       while(i < -15)
  426.       {
  427.          if(mapa.hitTest(_X - t,_Y + i,true))
  428.          {
  429.             u = true;
  430.             break;
  431.          }
  432.          i++;
  433.       }
  434.       return u;
  435.    }
  436.    function wallder()
  437.    {
  438.       var u = false;
  439.       var t = !slide ? 12 : 20;
  440.       i = -24;
  441.       while(i < -15)
  442.       {
  443.          if(mapa.hitTest(_X + t,_Y + i,true))
  444.          {
  445.             u = true;
  446.             break;
  447.          }
  448.          i++;
  449.       }
  450.       return u;
  451.    }
  452.    function setSpeed()
  453.    {
  454.       if(slideLeft && !rising)
  455.       {
  456.          forward = true;
  457.          backward = false;
  458.          if(horizontal == 0)
  459.          {
  460.             return hforce * -1;
  461.          }
  462.          return hforce * -1.5;
  463.       }
  464.       if(slideRight && !rising)
  465.       {
  466.          forward = false;
  467.          backward = true;
  468.          if(horizontal == 0)
  469.          {
  470.             return hforce;
  471.          }
  472.          return hforce * 1.5;
  473.       }
  474.       if(Key.isDown(DER) && keys && !wallder())
  475.       {
  476.          forward = false;
  477.          backward = true;
  478.          if(horizontal == 0)
  479.          {
  480.             return hforcei;
  481.          }
  482.          return hforce;
  483.       }
  484.       if(Key.isDown(IZQ) && keys && !wallizq())
  485.       {
  486.          forward = true;
  487.          backward = false;
  488.          if(horizontal == 0)
  489.          {
  490.             return hforcei * -1;
  491.          }
  492.          return hforce * -1;
  493.       }
  494.       return 0;
  495.    }
  496.    function drawFrame()
  497.    {
  498.       if(victory)
  499.       {
  500.          this.gotoAndStop("victory");
  501.          return undefined;
  502.       }
  503.       if(death)
  504.       {
  505.          this.gotoAndStop("death");
  506.          return undefined;
  507.       }
  508.       if(flashing)
  509.       {
  510.          this.gotoAndStop("hitted");
  511.          return undefined;
  512.       }
  513.       if(lastX != _X)
  514.       {
  515.          !forward ? (_xscale = Math.abs(_xscale)) : (_xscale = Math.abs(_xscale) * -1);
  516.       }
  517.       if(!shooting)
  518.       {
  519.          if(lastY > _Y && rising)
  520.          {
  521.             this.gotoAndStop("jump");
  522.             _root.estado = 3;
  523.             return undefined;
  524.          }
  525.       }
  526.       else if(lastY > _Y && rising)
  527.       {
  528.          this.gotoAndStop("attackJ");
  529.          _root.estado = 4;
  530.          return undefined;
  531.       }
  532.       if(lastY < _Y && falling || floating)
  533.       {
  534.          this.gotoAndStop("fall");
  535.          _root.estado = 5;
  536.          return undefined;
  537.       }
  538.       if(slide)
  539.       {
  540.          this.gotoAndStop("slide");
  541.          _root.estado = 6;
  542.          return undefined;
  543.       }
  544.       if(shooting)
  545.       {
  546.          if(horizontal != _root.windx)
  547.          {
  548.             this.gotoAndStop("attackRU");
  549.             sprite.gotoAndPlay(frame);
  550.             _root.estado = 2;
  551.             return undefined;
  552.          }
  553.       }
  554.       else if(horizontal != _root.windx)
  555.       {
  556.          this.gotoAndStop("run");
  557.          _root.estado = 1;
  558.          return undefined;
  559.       }
  560.       if(shooting)
  561.       {
  562.          this.gotoAndStop("attackST");
  563.       }
  564.       else
  565.       {
  566.          this.gotoAndStop("standing");
  567.       }
  568.    }
  569.    render();
  570.    frame = sprite._currentframe;
  571. }
  572.